home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / osi / isode / dosisode / DOSISODE80.ZIP / ISODE8.WRK / PEPSY / LEX.C_N next >
Encoding:
Text File  |  1992-06-28  |  25.5 KB  |  1,196 lines
  1. # include "stdio.h"
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX BUFSIZ
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin = {stdin}, *yyout = {stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. #ifndef    lint
  29. static char *RCSid = "$Header: /xtel/isode/isode/pepsy/RCS/lex.l.gnrc,v 9.0 1992/06/16 12:24:03 isode Rel $";
  30. #endif
  31.  
  32. /* 
  33.  * $Header: /xtel/isode/isode/pepsy/RCS/lex.l.gnrc,v 9.0 1992/06/16 12:24:03 isode Rel $
  34.  *
  35.  *
  36.  * $Log: lex.l.gnrc,v $
  37.  * Revision 9.0  1992/06/16  12:24:03  isode
  38.  * Release 8.0
  39.  *
  40.  */
  41.  
  42. /*
  43.  *                  NOTICE
  44.  *
  45.  *    Acquisition, use, and distribution of this module and related
  46.  *    materials are subject to the restrictions of a license agreement.
  47.  *    Consult the Preface in the User's Manual for the full terms of
  48.  *    this agreement.
  49.  *
  50.  *
  51.  */
  52.  
  53.  
  54. struct table {
  55.     char   *t_keyword;
  56.     int        t_value;
  57.     int        t_porting;
  58. };
  59.  
  60. static struct table reserved[] = {
  61.     "ABSENT", ABSENT, 0,
  62.     "ANY", ANY, 0,
  63.     "APPLICATION", APPLICATION, 0,
  64.     "BEGIN", BGIN, 0,
  65.     "BIT", BIT, 0,
  66.     "BITSTRING", BITSTRING, 0,
  67.     "BOOLEAN", BOOLEAN, 0,
  68.     "BY", BY, 0,
  69.     "CHOICE", CHOICE, 0,
  70.     "COMPONENT", COMPONENT, 0,
  71.     "COMPONENTS", COMPONENTS, 0,
  72.     "COMPONENTSOF", COMPONENTSOF, 0,
  73.     "DECODER", DECODER, 0,
  74.     "DEFAULT", DEFAULT, 0,
  75.     "DEFINED", DEFINED, 0,
  76.     "DEFINITIONS", DEFINITIONS, 0,
  77.     "ENCODER", ENCODER, 0,
  78.     "ENCRYPTED", ENCRYPTED, 0,
  79.     "END", END, 0,
  80.     "ENUMERATED", ENUMERATED, 0,
  81.     "EXPLICIT", EXPLICIT, 0,
  82.     "EXPORTS", EXPORTS, 0,
  83.     "FALSE", L_FALSE, 0,
  84.     "FROM", FROM, 0,
  85.     "IDENTIFIER", IDENTIFIER, 0,
  86.     "IMPLICIT", IMPLICIT, 0,
  87.     "IMPORTS", IMPORTS, 0,
  88.     "INCLUDE", INCLUDES, 0,
  89.     "INTEGER", INTEGER, 0,
  90.     "MIN", MIN, 0,
  91.     "MAX", MAX, 0,
  92.     "NULL", NIL, 0,
  93.     "OBJECT", OBJECT, 0,
  94.     "OCTET", OCTET, 0,
  95.     "OCTETSTRING", OCTETSTRING, 0,
  96.     "OF", OF, 0,
  97.     "OPTIONAL", OPTIONAL, 0,
  98.     "PREFIXES", PREFIXES, 0,
  99.     "PRESENT", PRESENT, 0,
  100.     "PRINTER", PRINTER, 0,
  101.     "PRIVATE", PRIVATE, 0,
  102.     "REAL", REAL, 0,
  103.     "SECTIONS", SECTIONS, 0,
  104.     "SEQUENCE", SEQUENCE, 0,
  105.     "SEQUENCEOF", SEQUENCEOF, 0,
  106.     "SET", SET, 0,
  107.     "SETOF", SETOF, 0,
  108.     "SIZE", SIZE, 0,
  109.     "STRING", STRING, 0,
  110.     "TAGS", TAGS, 0,
  111.     "TRUE", L_TRUE, 0,
  112.     "UNIVERSAL", UNIVERSAL, 0,
  113.     "WITH", WITH, 0,
  114.     "PLUS-INFINITY", PLUSINFINITY, 0,
  115.     "MINUS-INFINITY", MINUSINFINITY, 0,
  116.     NULL, 0
  117. };
  118.  
  119. # define YYNEWLINE 10
  120. yylex(){
  121. int nstr; extern int yyprevious;
  122. while((nstr = yylook()) >= 0)
  123. yyfussy: switch(nstr){
  124. case 0:
  125. if(yywrap()) return(0); break;
  126. case 1:
  127.         {   register int c, d;
  128.  
  129.                 for (d = 0; c = input (); d = c == '-')
  130.                 if (c == '\n' || (d && c == '-'))
  131.                     break;
  132.             }
  133. break;
  134. case 2:
  135.         {
  136.                 if (yydebug)
  137.                 fprintf (stderr, "WT\n");
  138.             }
  139. break;
  140. case 3:
  141.         {
  142.                 if (yydebug)
  143.                 fprintf (stderr, "NL\n");
  144.             }
  145. break;
  146. case 4:
  147.         {
  148.                 if (yydebug)
  149.                 fprintf (stderr, "SY: CCE\n");
  150.                 return CCE;
  151.             }
  152. break;
  153. case 5:
  154.         {
  155.                 if (yydebug)
  156.                     fprintf (stderr, "SY: DOTDOTDOT\n");
  157.                 return DOTDOTDOT;
  158.             }
  159. break;
  160. case 6:
  161.         {
  162.                     if (yydebug)
  163.                 fprintf (stderr, "SY: DOTDOT\n");
  164.                 return DOTDOT;
  165.             }
  166. break;
  167. case 7:
  168.         {
  169.                 if (yydebug)
  170.                 fprintf (stderr, "SY: DOT\n");
  171.                 return DOT;
  172.             }
  173. break;
  174. case 8:
  175.         {
  176.                 if (yydebug)
  177.                 fprintf (stderr, "SY: SEMICOLON");
  178.                 return SEMICOLON;
  179.             }
  180. break;
  181. case 9:
  182.         {
  183.                 if (yydebug)
  184.                 fprintf (stderr, "SY: COMMA\n");
  185.                 return COMMA;
  186.             }
  187. break;
  188. case 10:
  189.         {
  190.                 if (yydebug)
  191.                 fprintf (stderr, "SY: LBRACE\n");
  192.                 return LBRACE;
  193.             }
  194. break;
  195. case 11:
  196.         {
  197.                 if (yydebug)
  198.                 fprintf (stderr, "SY: RBRACE\n");
  199.                 return RBRACE;
  200.             }
  201. break;
  202. case 12:
  203.         {
  204.                 if (yydebug)
  205.                 fprintf (stderr, "SY: BAR\n");
  206.                 return BAR;
  207.             }
  208. break;
  209. case 13:
  210.         {
  211.                 if (yydebug)
  212.                 fprintf (stderr, "SY: MINUS\n");
  213.                 return MINUS;
  214.             }
  215. break;
  216. case 14:
  217.         {
  218.                 if (yydebug)
  219.                 fprintf (stderr, "SY: PLUS\n");
  220.                 return PLUS;
  221.             }
  222. break;
  223. case 15:
  224.     {   register int tok, c, d, len;
  225.                 register char *cp, *ep, *pp;
  226.  
  227.                 if (*yytext == '$')
  228.                 tok = VLENGTH;
  229.                 else
  230.                 if (*yytext == '<')
  231.                     tok = CONTROL;
  232.                 else {
  233.                     while((c = input()) == ' ' || c =='\t')
  234.                         continue;
  235.                     switch (c) {
  236.                     case 'a': tok = VALA;
  237.                           break;
  238.                     case 'b': tok = VALB;
  239.                           break;
  240.                     case 'i': tok = VALI;
  241.                           break;
  242.                     case 's': tok = VALS;
  243.                           break;
  244.                     case 'o': tok = VALO;
  245.                           break;
  246.                     case 'x': tok = VALX;
  247.                           break;
  248.                     case 'p': tok = VALP;
  249.                           break;
  250.                     case 'q': tok = VALQ;
  251.                               break;
  252.                     case 'r': tok = VALR;
  253.                           break;
  254.                     case 't': tok = VALT;
  255.                           break;
  256.                     case 'O': tok = VALOID;
  257.                           break;
  258.                     case 'P': tok = PARAMETERTYPE;
  259.                               break;
  260.                     case 'T': tok = VALTYPE;
  261.                           break;
  262.                     case 'E': tok = ENC_FN;
  263.                           break;
  264.                     case 'D': tok = DEC_FN;
  265.                           break;
  266.                     case 'F': tok = FRE_FN;
  267.                           break;
  268.                     default : myyerror ("unknown token: \"%s\"", yytext);
  269.                           break;
  270.                     }
  271.                     if ((c = input()) != ' ' && c != '\t'
  272.                     && c != '\n')
  273.                     yyerror ("syntax error in [[ ... ]]");
  274.                 }
  275.  
  276.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  277.                     == NULL)
  278.                 yyerror ("out of memory");
  279.  
  280.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  281.                 if ((c = input ()) == NULL)
  282.                     yyerror ("end-of-file while reading value");
  283.                 if ((d == ']' && c == ']' && tok !=CONTROL) ||
  284.                     (c == '$' && (tok ==VALX || tok ==VALO)) ||
  285.                     (d == '>' && c == '>' && tok ==CONTROL)) {
  286.                     if ((tok == VALX || tok == VALO) &&
  287.                        (c != '$'))
  288.                        yyerror("Missing '$' in [[ - ]]");
  289.                     if (c == '$') {unput(c); *cp = NULL;}
  290.                     else *--cp = NULL;
  291.                     yylval.yy_string = pp;
  292.                     if (yydebug)
  293.                     fprintf (stderr, "VAL: \"%s\"\n",
  294.                         yylval.yy_string);
  295.                     return tok;
  296.                 }
  297.                 if (cp >= ep) {
  298.                     register int curlen = cp - pp;
  299.                     register char *dp;
  300.  
  301.                     if ((dp = realloc (pp,
  302.                         (unsigned) (len += BUFSIZ)))
  303.                         == NULL)
  304.                     yyerror ("out of memory");
  305.                     cp = dp + curlen;
  306.                     ep = (pp = dp) + len - 1;
  307.                 }
  308.                 *cp++ = c;
  309.                 }
  310.             }
  311. break;
  312. case 16:
  313.         {
  314.                 if (yydebug)
  315.                 fprintf (stderr, "SY: LBRACKET\n");
  316.                 return LBRACKET;
  317.             }
  318. break;
  319. case 17:
  320.         {
  321.                 if (yydebug)
  322.                 fprintf (stderr, "SY: RBRACKET\n");
  323.                 return RBRACKET;
  324.             }
  325. break;
  326. case 18:
  327.         {
  328.                 if (yydebug)
  329.                 fprintf (stderr, "SY: LANGLE\n");
  330.                 return LANGLE;
  331.             }
  332. break;
  333. case 19:
  334.         {
  335.                 if (yydebug)
  336.                 fprintf (stderr, "SY: LPAREN\n");
  337.                 return LPAREN;
  338.             }
  339. break;
  340. case 20:
  341.         {
  342.                 if (yydebug)
  343.                 fprintf (stderr, "SY: RPAREN\n");
  344.                 return RPAREN;
  345.             }
  346. break;
  347. case 21:
  348.         {
  349.                 if (yydebug)
  350.                 fprintf (stderr, "SY: STAR\n");
  351.                 return STAR;
  352.             }
  353. break;
  354. case 22:
  355.         {
  356.                 (void) sscanf (yytext, "%d", &yylval.yy_number);
  357.                 if (yydebug)
  358.                 fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
  359.                 return LITNUMBER;
  360.             }
  361. break;
  362. case 23:
  363.         {
  364.                 (void) sscanf (yytext, "%d", &yylval.yy_number);
  365.                 if (yydebug)
  366.                 fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
  367.                 return LITNUMBER;
  368.             }
  369. break;
  370. case 24:
  371.     {   register char *cp; register int i;
  372.  
  373.                 switch (*(cp = yytext + strlen (yytext) - 1)) {
  374.                 case 'H':
  375.                 case 'h':
  376.                     *--cp = NULL;
  377.                     for (cp = yytext + 1; *cp; cp++)
  378.                     if (!isxdigit(*cp))
  379.                         yyerror ("bad hex string");
  380.                     yylval.yy_string = new_string(yytext + 1);
  381.                     if (yydebug)
  382.                     fprintf (stderr,
  383.                         "HSTRING: %s\n", yylval.yy_string);
  384.                     return HSTRING;
  385.  
  386.                 case 'B':
  387.                 case 'b':
  388.                     *--cp = NULL;
  389.                     for (cp = yytext + 1; *cp; cp++)
  390.                     if (*cp != '0' && *cp != '1')
  391.                         yyerror ("bad bit string");
  392.                     yylval.yy_string = new_string(yytext + 1);
  393.                     if (yydebug)
  394.                     fprintf (stderr,
  395.                         "BSTRING: %s\n", yylval.yy_string);
  396.                     return BSTRING;
  397.                 }
  398.                 yyerror ("illegal string");
  399.             }
  400. break;
  401. case 25:
  402.     {
  403.                 yytext[strlen (yytext) - 1] = NULL;
  404.                 yylval.yy_string = new_string (yytext + 1);
  405.                 if (yydebug)
  406.                 fprintf (stderr, "LIT: \"%s\"\n", yylval.yy_string);
  407.                 return LITSTRING;
  408.             }
  409. break;
  410. case 26:
  411. {   register struct table *t;
  412.  
  413.                 for (t = reserved; t -> t_keyword; t++)
  414.                 if (strcmp (t -> t_keyword, yytext) == 0) {
  415.                     if (yyporting && t -> t_porting)
  416.                     break;
  417.                     if (yydebug)
  418.                     fprintf (stderr,
  419.                           "KE: \"%s\"\n", yytext);
  420.                     yylval.yy_number = yylineno;
  421.                     return t -> t_value;
  422.                 }
  423.                 yylval.yy_string = new_string (yytext);
  424.                 if (yydebug)
  425.                 fprintf (stderr, "ID: \"%s\"\n", yylval.yy_string);
  426.                 return ID;
  427.             }
  428. break;
  429. case 27:
  430. {   yylval.yy_string = new_string (yytext);
  431.                 if (yydebug)
  432.                 fprintf (stderr, "NAME: \"%s\"\n", yylval.yy_string);
  433.                 return NAME;
  434.             }
  435. break;
  436. case 28:
  437.         {   register int c, d, len;
  438.                 register char *cp, *ep, *pp;
  439.  
  440.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  441.                     == NULL)
  442.                 yyerror ("out of memory");
  443.  
  444.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  445.                 if ((c = input ()) == NULL)
  446.                     yyerror ("end-of-file while reading value");
  447.                 if (d == '%' && c == ']' ) {
  448.                     *--cp = NULL;
  449.                     yylval.yy_string = pp;
  450.                     if (yydebug)
  451.                     fprintf (stderr, "VAL: \"%s\"\n",
  452.                          yylval.yy_string);
  453.                     return SCTRL;
  454.                 }
  455.                 if (d == '\n')
  456.                     yyerror ("newline in %[ %] construct");
  457.                 if (cp >= ep) {
  458.                     register int curlen = cp - pp;
  459.                     register char *dp;
  460.  
  461.                     if ((dp = realloc (pp,
  462.                         (unsigned) (len += BUFSIZ)))
  463.                         == NULL)
  464.                     yyerror ("out of memory");
  465.                     cp = dp + curlen;
  466.                     ep = (pp = dp) + len - 1;
  467.                 }
  468.                 *cp++ = c;
  469.                 }
  470.             }
  471. break;
  472. case 29:
  473.         {   register int c, d, len;
  474.                 int        mylineno;
  475.                 register char *cp, *ep, *pp;
  476.  
  477.                 mylineno = yylineno;
  478.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  479.                     == NULL)
  480.                 yyerror ("out of memory");
  481.  
  482.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  483.                 if ((c = input ()) == NULL)
  484.                     yyerror ("end-of-file while reading action");
  485.                 if (d == '%' && c == '}') {
  486.                     *--cp = NULL;
  487.                     yylval.yy_action = new_action (pp, mylineno);;
  488.                     if (yydebug)
  489.                     fprintf (stderr, "ACTION: \"%s\", %d\n",
  490.                         yylval.yy_action -> ya_text,
  491.                         yylval.yy_action -> ya_lineno);
  492.                     return ACTION;
  493.                 }
  494.                 if (cp >= ep) {
  495.                     register int curlen = cp - pp;
  496.                     register char *dp;
  497.  
  498.                     if ((dp = realloc (pp,
  499.                         (unsigned) (len += BUFSIZ)))
  500.                         == NULL)
  501.                     yyerror ("out of memory");
  502.                     cp = dp + curlen;
  503.                     ep = (pp = dp) + len - 1;
  504.                 }
  505.                 *cp++ = c;
  506.                 }
  507.             }
  508. break;
  509. case 30:
  510.         {   register int c, d, len;
  511.                 int        mylineno;
  512.                 register char *cp, *ep, *pp;
  513.                 int c_typ = (yytext[1] == 'D' ? DCHOICE :
  514.                 (yytext[1] == 'E' ? ECHOICE : PCHOICE));
  515.  
  516.                 mylineno = yylineno;
  517.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  518.                     == NULL)
  519.                 yyerror ("out of memory");
  520.  
  521.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  522.                 if ((c = input ()) == NULL)
  523.                     yyerror ("end-of-file while reading action");
  524.                 if (d == '>' && c == '>') {
  525.                     *--cp = NULL;
  526.                     yylval.yy_action = new_action (pp, mylineno);;
  527.                     if (yydebug)
  528.                     fprintf (stderr,"%cCHOICE: \"%s\", %d\n",
  529.                          yytext[1],
  530.                         yylval.yy_action -> ya_text,
  531.                         yylval.yy_action -> ya_lineno);
  532.                     return c_typ;
  533.                 }
  534.                 if (cp >= ep) {
  535.                     register int curlen = cp - pp;
  536.                     register char *dp;
  537.  
  538.                     if ((dp = realloc (pp,
  539.                         (unsigned) (len += BUFSIZ)))
  540.                         == NULL)
  541.                     yyerror ("out of memory");
  542.                     cp = dp + curlen;
  543.                     ep = (pp = dp) + len - 1;
  544.                 }
  545.                 *cp++ = c;
  546.                 }
  547.             }
  548. break;
  549. case 31:
  550.         {   register int c, d, len;
  551.                 int        mylineno;
  552.                 register char *cp, *ep, *pp;
  553.  
  554.                 mylineno = yylineno;
  555.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  556.                     == NULL)
  557.                 yyerror ("out of memory");
  558.  
  559.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  560.                 if ((c = input ()) == NULL)
  561.                     yyerror ("end-of-file while reading action");
  562.                 if (d == '%' && c == '}') {
  563.                     *--cp = NULL;
  564.                     yylval.yy_action = new_action (pp, mylineno);;
  565.                     if (yydebug)
  566.                     fprintf (stderr,"EACTION: \"%s\", %d\n",
  567.                         yylval.yy_action -> ya_text,
  568.                         yylval.yy_action -> ya_lineno);
  569.                     return EACTION;
  570.                 }
  571.                 if (cp >= ep) {
  572.                     register int curlen = cp - pp;
  573.                     register char *dp;
  574.  
  575.                     if ((dp = realloc (pp,
  576.                         (unsigned) (len += BUFSIZ)))
  577.                         == NULL)
  578.                     yyerror ("out of memory");
  579.                     cp = dp + curlen;
  580.                     ep = (pp = dp) + len - 1;
  581.                 }
  582.                 *cp++ = c;
  583.                 }
  584.             }
  585. break;
  586. case 32:
  587.         {   register int c, d, len;
  588.                 int        mylineno;
  589.                 register char *cp, *ep, *pp;
  590.  
  591.                 mylineno = yylineno;
  592.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  593.                     == NULL)
  594.                 yyerror ("out of memory");
  595.  
  596.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  597.                 if ((c = input ()) == NULL)
  598.                     yyerror ("end-of-file while reading action");
  599.                 if (d == '%' && c == '}') {
  600.                     *--cp = NULL;
  601.                     yylval.yy_action = new_action (pp, mylineno);;
  602.                     if (yydebug)
  603.                     fprintf (stderr,"DACTION: \"%s\", %d\n",
  604.                         yylval.yy_action -> ya_text,
  605.                         yylval.yy_action -> ya_lineno);
  606.                     return DACTION;
  607.                 }
  608.                 if (cp >= ep) {
  609.                     register int curlen = cp - pp;
  610.                     register char *dp;
  611.  
  612.                     if ((dp = realloc (pp,
  613.                         (unsigned) (len += BUFSIZ)))
  614.                         == NULL)
  615.                     yyerror ("out of memory");
  616.                     cp = dp + curlen;
  617.                     ep = (pp = dp) + len - 1;
  618.                 }
  619.                 *cp++ = c;
  620.                 }
  621.             }
  622. break;
  623. case 33:
  624.         {   register int c, d, len;
  625.                 int        mylineno;
  626.                 register char *cp, *ep, *pp;
  627.  
  628.                 mylineno = yylineno;
  629.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  630.                     == NULL)
  631.                 yyerror ("out of memory");
  632.  
  633.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  634.                 if ((c = input ()) == NULL)
  635.                     yyerror ("end-of-file while reading action");
  636.                 if (d == '%' && c == '}') {
  637.                     *--cp = NULL;
  638.                     yylval.yy_action = new_action (pp, mylineno);;
  639.                     if (yydebug)
  640.                     fprintf (stderr,"PACTION: \"%s\", %d\n",
  641.                         yylval.yy_action -> ya_text,
  642.                         yylval.yy_action -> ya_lineno);
  643.                     return PACTION;
  644.                 }
  645.                 if (cp >= ep) {
  646.                     register int curlen = cp - pp;
  647.                     register char *dp;
  648.  
  649.                     if ((dp = realloc (pp,
  650.                         (unsigned) (len += BUFSIZ)))
  651.                         == NULL)
  652.                     yyerror ("out of memory");
  653.                     cp = dp + curlen;
  654.                     ep = (pp = dp) + len - 1;
  655.                 }
  656.                 *cp++ = c;
  657.                 }
  658.             }
  659. break;
  660. case 34:
  661.         {   
  662.                 myyerror ("unknown token: \"%s\"", yytext);
  663.             }
  664. break;
  665. case -1:
  666. break;
  667. default:
  668. fprintf(yyout,"bad switch yylook %d",nstr);
  669. } return(0); }
  670. /* end of yylex */
  671. int yyvstop[] = {
  672. 0,
  673.  
  674. 2,
  675. 0,
  676.  
  677. 2,
  678. 0,
  679.  
  680. 34,
  681. 0,
  682.  
  683. 2,
  684. 34,
  685. 0,
  686.  
  687. 3,
  688. 0,
  689.  
  690. 34,
  691. 0,
  692.  
  693. 15,
  694. 34,
  695. 0,
  696.  
  697. 34,
  698. 0,
  699.  
  700. 34,
  701. 0,
  702.  
  703. 19,
  704. 34,
  705. 0,
  706.  
  707. 20,
  708. 34,
  709. 0,
  710.  
  711. 21,
  712. 34,
  713. 0,
  714.  
  715. 14,
  716. 34,
  717. 0,
  718.  
  719. 9,
  720. 34,
  721. 0,
  722.  
  723. 13,
  724. 34,
  725. 0,
  726.  
  727. 7,
  728. 34,
  729. 0,
  730.  
  731. 22,
  732. 34,
  733. 0,
  734.  
  735. 34,
  736. 0,
  737.  
  738. 8,
  739. 34,
  740. 0,
  741.  
  742. 18,
  743. 34,
  744. 0,
  745.  
  746. 26,
  747. 34,
  748. 0,
  749.  
  750. 16,
  751. 34,
  752. 0,
  753.  
  754. 17,
  755. 34,
  756. 0,
  757.  
  758. 27,
  759. 34,
  760. 0,
  761.  
  762. 10,
  763. 34,
  764. 0,
  765.  
  766. 12,
  767. 34,
  768. 0,
  769.  
  770. 11,
  771. 34,
  772. 0,
  773.  
  774. 2,
  775. 0,
  776.  
  777. 25,
  778. 0,
  779.  
  780. 28,
  781. 0,
  782.  
  783. 29,
  784. 0,
  785.  
  786. 1,
  787. 0,
  788.  
  789. 23,
  790. 0,
  791.  
  792. 6,
  793. 0,
  794.  
  795. 22,
  796. 0,
  797.  
  798. 15,
  799. 0,
  800.  
  801. 26,
  802. 0,
  803.  
  804. 27,
  805. 0,
  806.  
  807. 32,
  808. 0,
  809.  
  810. 31,
  811. 0,
  812.  
  813. 33,
  814. 0,
  815.  
  816. 24,
  817. 0,
  818.  
  819. 5,
  820. 0,
  821.  
  822. 4,
  823. 0,
  824.  
  825. 30,
  826. 0,
  827. 0};
  828. # define YYTYPE char
  829. struct yywork { YYTYPE verify, advance; } yycrank[] = {
  830. 0,0,    0,0,    1,3,    0,0,    
  831. 0,0,    0,0,    0,0,    0,0,    
  832. 0,0,    0,0,    1,4,    1,5,    
  833. 0,0,    4,28,    0,0,    0,0,    
  834. 0,0,    0,0,    0,0,    0,0,    
  835. 0,0,    0,0,    0,0,    0,0,    
  836. 0,0,    0,0,    0,0,    0,0,    
  837. 0,0,    0,0,    0,0,    0,0,    
  838. 0,0,    0,0,    0,0,    1,6,    
  839. 4,28,    1,7,    1,8,    29,0,    
  840. 1,9,    1,10,    1,11,    1,12,    
  841. 1,13,    1,14,    1,15,    1,16,    
  842. 16,40,    1,17,    36,0,    0,0,    
  843. 0,0,    40,51,    0,0,    0,0,    
  844. 0,0,    0,0,    0,0,    1,18,    
  845. 1,19,    1,20,    18,42,    0,0,    
  846. 0,0,    0,0,    1,21,    1,21,    
  847. 42,52,    1,21,    44,53,    0,0,    
  848. 0,0,    0,0,    2,8,    0,0,    
  849. 6,29,    2,10,    2,11,    2,12,    
  850. 2,13,    2,14,    0,0,    2,16,    
  851. 6,29,    6,29,    0,0,    0,0,    
  852. 0,0,    8,31,    8,32,    0,0,    
  853. 1,22,    22,43,    1,23,    2,18,    
  854. 2,19,    2,20,    1,24,    1,24,    
  855. 0,0,    8,33,    0,0,    0,0,    
  856. 0,0,    0,0,    0,0,    20,43,    
  857. 0,0,    6,30,    0,0,    6,0,    
  858. 8,34,    0,0,    6,29,    20,44,    
  859. 20,44,    0,0,    0,0,    0,0,    
  860. 6,29,    0,0,    0,0,    6,29,    
  861. 1,25,    1,26,    1,27,    20,44,    
  862. 2,22,    31,47,    2,23,    32,48,    
  863. 33,49,    37,50,    0,0,    0,0,    
  864. 0,0,    0,0,    0,0,    37,50,    
  865. 6,29,    6,29,    9,36,    6,29,    
  866. 8,35,    0,0,    0,0,    0,0,    
  867. 0,0,    0,0,    9,36,    9,36,    
  868. 0,0,    0,0,    0,0,    0,0,    
  869. 0,0,    0,0,    0,0,    0,0,    
  870. 2,25,    2,26,    2,27,    0,0,    
  871. 0,0,    37,50,    0,0,    0,0,    
  872. 0,0,    0,0,    0,0,    37,50,    
  873. 6,29,    6,29,    0,0,    9,36,    
  874. 0,0,    9,0,    0,0,    0,0,    
  875. 9,37,    0,0,    0,0,    0,0,    
  876. 0,0,    0,0,    9,36,    15,38,    
  877. 0,0,    9,36,    15,39,    15,39,    
  878. 15,39,    15,39,    15,39,    15,39,    
  879. 15,39,    15,39,    15,39,    15,39,    
  880. 0,0,    0,0,    0,0,    0,0,    
  881. 0,0,    0,0,    9,36,    9,36,    
  882. 0,0,    9,36,    17,41,    17,41,    
  883. 17,41,    17,41,    17,41,    17,41,    
  884. 17,41,    17,41,    17,41,    17,41,    
  885. 21,45,    0,0,    0,0,    21,45,    
  886. 21,45,    21,45,    21,45,    21,45,    
  887. 21,45,    21,45,    21,45,    21,45,    
  888. 21,45,    0,0,    0,0,    0,0,    
  889. 0,0,    0,0,    9,36,    9,36,    
  890. 21,45,    21,45,    21,45,    21,45,    
  891. 21,45,    21,45,    21,45,    21,45,    
  892. 21,45,    21,45,    21,45,    21,45,    
  893. 21,45,    21,45,    21,45,    21,45,    
  894. 21,45,    21,45,    21,45,    21,45,    
  895. 21,45,    21,45,    21,45,    21,45,    
  896. 21,45,    21,45,    0,0,    0,0,    
  897. 0,0,    0,0,    0,0,    0,0,    
  898. 21,45,    21,45,    21,45,    21,45,    
  899. 21,45,    21,45,    21,45,    21,45,    
  900. 21,45,    21,45,    21,45,    21,45,    
  901. 21,45,    21,45,    21,45,    21,45,    
  902. 21,45,    21,45,    21,45,    21,45,    
  903. 21,45,    21,45,    21,45,    21,45,    
  904. 21,45,    21,45,    24,46,    0,0,    
  905. 0,0,    24,46,    24,46,    24,46,    
  906. 24,46,    24,46,    24,46,    24,46,    
  907. 24,46,    24,46,    24,46,    0,0,    
  908. 0,0,    0,0,    0,0,    0,0,    
  909. 0,0,    0,0,    24,46,    24,46,    
  910. 24,46,    24,46,    24,46,    24,46,    
  911. 24,46,    24,46,    24,46,    24,46,    
  912. 24,46,    24,46,    24,46,    24,46,    
  913. 24,46,    24,46,    24,46,    24,46,    
  914. 24,46,    24,46,    24,46,    24,46,    
  915. 24,46,    24,46,    24,46,    24,46,    
  916. 0,0,    0,0,    0,0,    0,0,    
  917. 0,0,    0,0,    24,46,    24,46,    
  918. 24,46,    24,46,    24,46,    24,46,    
  919. 24,46,    24,46,    24,46,    24,46,    
  920. 24,46,    24,46,    24,46,    24,46,    
  921. 24,46,    24,46,    24,46,    24,46,    
  922. 24,46,    24,46,    24,46,    24,46,    
  923. 24,46,    24,46,    24,46,    24,46,    
  924. 39,39,    39,39,    39,39,    39,39,    
  925. 39,39,    39,39,    39,39,    39,39,    
  926. 39,39,    39,39,    0,0,    0,0,    
  927. 0,0};
  928. struct yysvf yysvec[] = {
  929. 0,    0,    0,
  930. yycrank+-1,    0,        yyvstop+1,
  931. yycrank+-37,    yysvec+1,    yyvstop+3,
  932. yycrank+0,    0,        yyvstop+5,
  933. yycrank+4,    0,        yyvstop+7,
  934. yycrank+0,    0,        yyvstop+10,
  935. yycrank+-75,    0,        yyvstop+12,
  936. yycrank+0,    0,        yyvstop+14,
  937. yycrank+21,    0,        yyvstop+17,
  938. yycrank+-141,    0,        yyvstop+19,
  939. yycrank+0,    0,        yyvstop+21,
  940. yycrank+0,    0,        yyvstop+24,
  941. yycrank+0,    0,        yyvstop+27,
  942. yycrank+0,    0,        yyvstop+30,
  943. yycrank+0,    0,        yyvstop+33,
  944. yycrank+142,    0,        yyvstop+36,
  945. yycrank+2,    0,        yyvstop+39,
  946. yycrank+162,    0,        yyvstop+42,
  947. yycrank+4,    0,        yyvstop+45,
  948. yycrank+0,    0,        yyvstop+47,
  949. yycrank+47,    0,        yyvstop+50,
  950. yycrank+175,    0,        yyvstop+53,
  951. yycrank+2,    0,        yyvstop+56,
  952. yycrank+0,    0,        yyvstop+59,
  953. yycrank+253,    0,        yyvstop+62,
  954. yycrank+0,    0,        yyvstop+65,
  955. yycrank+0,    0,        yyvstop+68,
  956. yycrank+0,    0,        yyvstop+71,
  957. yycrank+0,    yysvec+4,    yyvstop+74,
  958. yycrank+-3,    yysvec+6,    0,    
  959. yycrank+0,    0,        yyvstop+76,
  960. yycrank+6,    0,        0,    
  961. yycrank+8,    0,        0,    
  962. yycrank+9,    0,        0,    
  963. yycrank+0,    0,        yyvstop+78,
  964. yycrank+0,    0,        yyvstop+80,
  965. yycrank+-14,    yysvec+9,    0,    
  966. yycrank+67,    0,        0,    
  967. yycrank+0,    0,        yyvstop+82,
  968. yycrank+328,    0,        yyvstop+84,
  969. yycrank+7,    0,        yyvstop+86,
  970. yycrank+0,    yysvec+17,    yyvstop+88,
  971. yycrank+7,    0,        0,    
  972. yycrank+0,    0,        yyvstop+90,
  973. yycrank+10,    0,        0,    
  974. yycrank+0,    yysvec+21,    yyvstop+92,
  975. yycrank+0,    yysvec+24,    yyvstop+94,
  976. yycrank+0,    0,        yyvstop+96,
  977. yycrank+0,    0,        yyvstop+98,
  978. yycrank+0,    0,        yyvstop+100,
  979. yycrank+0,    0,        yyvstop+102,
  980. yycrank+0,    0,        yyvstop+104,
  981. yycrank+0,    0,        yyvstop+106,
  982. yycrank+0,    0,        yyvstop+108,
  983. 0,    0,    0};
  984. struct yywork *yytop = yycrank+385;
  985. struct yysvf *yybgin = yysvec+1;
  986. char yymatch[] = {
  987. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  988. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  989. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  990. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  991. 011 ,01  ,'"' ,01  ,'$' ,01  ,01  ,047 ,
  992. 01  ,01  ,01  ,01  ,01  ,'-' ,01  ,01  ,
  993. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  994. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  995. 01  ,'A' ,'B' ,'A' ,'D' ,'D' ,'A' ,'A' ,
  996. 'B' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  997. 'D' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  998. 'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
  999. 01  ,'a' ,'b' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  1000. 'b' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  1001. 'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  1002. 'a' ,'a' ,'a' ,01  ,01  ,01  ,01  ,01  ,
  1003. 0};
  1004. char yyextra[] = {
  1005. 0,0,0,0,0,0,0,0,
  1006. 0,0,0,0,0,0,0,0,
  1007. 0,0,0,0,0,0,0,0,
  1008. 0,0,0,0,0,0,0,0,
  1009. 0,0,0,0,0,0,0,0,
  1010. 0};
  1011. #ifndef lint
  1012. static    char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
  1013. #endif
  1014.  
  1015. int yylineno =1;
  1016. # define YYU(x) x
  1017. # define NLSTATE yyprevious=YYNEWLINE
  1018. char yytext[YYLMAX];
  1019. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  1020. char yysbuf[YYLMAX];
  1021. char *yysptr = yysbuf;
  1022. int *yyfnd;
  1023. extern struct yysvf *yyestate;
  1024. int yyprevious = YYNEWLINE;
  1025. yylook(){
  1026.     register struct yysvf *yystate, **lsp;
  1027.     register struct yywork *yyt;
  1028.     struct yysvf *yyz;
  1029.     int yych, yyfirst;
  1030.     struct yywork *yyr;
  1031. # ifdef LEXDEBUG
  1032.     int debug;
  1033. # endif
  1034.     char *yylastch;
  1035.     /* start off machines */
  1036. # ifdef LEXDEBUG
  1037.     debug = 0;
  1038. # endif
  1039.     yyfirst=1;
  1040.     if (!yymorfg)
  1041.         yylastch = yytext;
  1042.     else {
  1043.         yymorfg=0;
  1044.         yylastch = yytext+yyleng;
  1045.         }
  1046.     for(;;){
  1047.         lsp = yylstate;
  1048.         yyestate = yystate = yybgin;
  1049.         if (yyprevious==YYNEWLINE) yystate++;
  1050.         for (;;){
  1051. # ifdef LEXDEBUG
  1052.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  1053. # endif
  1054.             yyt = yystate->yystoff;
  1055.             if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  1056.                 yyz = yystate->yyother;
  1057.                 if(yyz == 0)break;
  1058.                 if(yyz->yystoff == yycrank)break;
  1059.                 }
  1060.             *yylastch++ = yych = input();
  1061.             yyfirst=0;
  1062.         tryagain:
  1063. # ifdef LEXDEBUG
  1064.             if(debug){
  1065.                 fprintf(yyout,"char ");
  1066.                 allprint(yych);
  1067.                 putchar('\n');
  1068.                 }
  1069. # endif
  1070.             yyr = yyt;
  1071.             if ( (int)yyt > (int)yycrank){
  1072.                 yyt = yyr + yych;
  1073.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  1074.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  1075.                         {unput(*--yylastch);break;}
  1076.                     *lsp++ = yystate = yyt->advance+yysvec;
  1077.                     goto contin;
  1078.                     }
  1079.                 }
  1080. # ifdef YYOPTIM
  1081.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  1082.                 yyt = yyr = yycrank+(yycrank-yyt);
  1083. # ifdef LEXDEBUG
  1084.                 if(debug)fprintf(yyout,"compressed state\n");
  1085. # endif
  1086.                 yyt = yyt + yych;
  1087.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  1088.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  1089.                         {unput(*--yylastch);break;}
  1090.                     *lsp++ = yystate = yyt->advance+yysvec;
  1091.                     goto contin;
  1092.                     }
  1093.                 yyt = yyr + YYU(yymatch[yych]);
  1094. # ifdef LEXDEBUG
  1095.                 if(debug){
  1096.                     fprintf(yyout,"try fall back character ");
  1097.                     allprint(YYU(yymatch[yych]));
  1098.                     putchar('\n');
  1099.                     }
  1100. # endif
  1101.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  1102.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  1103.                         {unput(*--yylastch);break;}
  1104.                     *lsp++ = yystate = yyt->advance+yysvec;
  1105.                     goto contin;
  1106.                     }
  1107.                 }
  1108.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  1109. # ifdef LEXDEBUG
  1110.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  1111. # endif
  1112.                 goto tryagain;
  1113.                 }
  1114. # endif
  1115.             else
  1116.                 {unput(*--yylastch);break;}
  1117.         contin:
  1118. # ifdef LEXDEBUG
  1119.             if(debug){
  1120.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  1121.                 allprint(yych);
  1122.                 putchar('\n');
  1123.                 }
  1124. # endif
  1125.             ;
  1126.             }
  1127. # ifdef LEXDEBUG
  1128.         if(debug){
  1129.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  1130.             allprint(yych);
  1131.             putchar('\n');
  1132.             }
  1133. # endif
  1134.         while (lsp-- > yylstate){
  1135.             *yylastch-- = 0;
  1136.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  1137.                 yyolsp = lsp;
  1138.                 if(yyextra[*yyfnd]){        /* must backup */
  1139.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  1140.                         lsp--;
  1141.                         unput(*yylastch--);
  1142.                         }
  1143.                     }
  1144.                 yyprevious = YYU(*yylastch);
  1145.                 yylsp = lsp;
  1146.                 yyleng = yylastch-yytext+1;
  1147.                 yytext[yyleng] = 0;
  1148. # ifdef LEXDEBUG
  1149.                 if(debug){
  1150.                     fprintf(yyout,"\nmatch ");
  1151.                     sprint(yytext);
  1152.                     fprintf(yyout," action %d\n",*yyfnd);
  1153.                     }
  1154. # endif
  1155.                 return(*yyfnd++);
  1156.                 }
  1157.             unput(*yylastch);
  1158.             }
  1159.         if (yytext[0] == 0  /* && feof(yyin) */)
  1160.             {
  1161.             yysptr=yysbuf;
  1162.             return(0);
  1163.             }
  1164.         yyprevious = yytext[0] = input();
  1165.         if (yyprevious>0)
  1166.             output(yyprevious);
  1167.         yylastch=yytext;
  1168. # ifdef LEXDEBUG
  1169.         if(debug)putchar('\n');
  1170. # endif
  1171.         }
  1172.     }
  1173. yyback(p, m)
  1174.     int *p;
  1175. {
  1176. if (p==0) return(0);
  1177. while (*p)
  1178.     {
  1179.     if (*p++ == m)
  1180.         return(1);
  1181.     }
  1182. return(0);
  1183. }
  1184.     /* the following are only used in the lex library */
  1185. yyinput(){
  1186.     return(input());
  1187.     }
  1188. yyoutput(c)
  1189.   int c; {
  1190.     output(c);
  1191.     }
  1192. yyunput(c)
  1193.    int c; {
  1194.     unput(c);
  1195.     }
  1196.